package com.navinfo.platform.trip.common.util;

import com.google.gson.*;
import com.google.gson.reflect.TypeToken;

import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;

/**
 * Gson工具类
 * @author ZhaiCY
 */
public final class GsonUtils {

    /**
     * Gson对象
     */
    private static Gson gson;

    static {
        gson = new GsonBuilder().serializeNulls().registerTypeHierarchyAdapter(byte[].class, new ByteArrayToBase64TypeAdapter()).create();
    }

    /**
     * 构造函数
     */
    private GsonUtils() {
    }

    /**
     * 转成json
     *
     * @param object 对象
     * @return json
     */
    public static String gsonString(Object object) {
        String gsonString = null;
        try {
            gsonString = gson.toJson(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return gsonString;
    }

    /**
     * 转成bean
     * @param gsonByte byte数组
     * @param cls      转换类型
     * @param <T>      泛型
     * @return 对象Bean
     */
    public static <T> T gsonToBean(byte[] gsonByte, Class<T> cls) {
        return gsonToBean(new String(gsonByte, StandardCharsets.UTF_8), cls);
    }

    /**
     * 转成bean
     *
     * @param gsonString json字符串
     * @param cls        转换类型
     * @param <T>        泛型
     * @return 对象Bean
     */
    public static <T> T gsonToBean(String gsonString, Class<T> cls) {
        return gson.fromJson(gsonString, cls);
    }

    /**
     * 转成list
     *
     * @param json json字符串
     * @param cls        转换类型
     * @param <T>        泛型
     * @return 对象Bean
     */
    public static <T> List<T> gsonToList(String json, Class<T> cls) {
        Type type = new TypeToken<ArrayList<JsonObject>>() {
        }.getType();
        ArrayList<JsonObject> jsonObjs = gson.fromJson(json, type);
        ArrayList<T> listOfT = new ArrayList<>();
        for (JsonObject jsonObj : jsonObjs) {
            listOfT.add(gson.fromJson(jsonObj, cls));
        }
        return listOfT;
    }

    /**
     * 转成list中有map的
     *
     * @param gsonString json字符串
     * @param <T>        泛型
     * @return 对象Bean
     */
    public static <T> List<Map<String, T>> gsonToListMap(String gsonString) {
        List<Map<String, T>> list = null;
        try {
            list = gson.fromJson(gsonString, new TypeToken<List<Map<String, T>>>() {
            }.getType());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 转成map的
     *
     * @param gsonString json字符串
     * @param <T>        泛型
     * @return 对象Bean
     */
    public static <K,T> Map<K, T> gsonToMap(String gsonString) {
        Map<K, T> map = null;
        try {
            map = gson.fromJson(gsonString, new TypeToken<Map<K, T>>() {
            }.getType());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    public static class ByteArrayToBase64TypeAdapter implements JsonSerializer<byte[]>, JsonDeserializer<byte[]> {
        /**
         * 反序列化
         *
         * @param json    JsonElement
         * @param typeOfT type
         * @param context JsonDeserializationContext
         * @return 反序列化后的字节
         * @throws JsonParseException 异常
         */
        @Override
        public byte[] deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
            return Base64.getDecoder().decode(json.getAsString());
        }

        /**
         * 序列化
         *
         * @param src       待序列化字节
         * @param typeOfSrc type
         * @param context   JsonDeserializationContext
         * @return JsonElement
         */
        @Override
        public JsonElement serialize(byte[] src, Type typeOfSrc, JsonSerializationContext context) {
            return new JsonPrimitive(Base64.getEncoder().encodeToString(src));
        }
    }
}
